import { createTool } from '@mastra/core/tools';
import { z } from 'zod';
import { SuspectDialogueRequestSchema, AgentResponseSchema } from '../types/game';

/**
 * 嫌疑人对话工具
 * 处理侦探与嫌疑人的对话交互，分析问题类型并生成相应回应
 */
export const suspectDialogueTool = createTool({
  id: 'suspect-dialogue',
  description: '处理侦探与嫌疑人的对话，分析问题并生成AI回应',
  inputSchema: SuspectDialogueRequestSchema,
  outputSchema: AgentResponseSchema,
  execute: async ({ context }) => {
    const { caseId, suspectId, question, conversationHistory, timeRemaining, discoveredClues } = context;
    return await processSuspectDialogue({
      caseId,
      suspectId,
      question,
      conversationHistory,
      timeRemaining,
      discoveredClues
    });
  },
});

/**
 * 处理嫌疑人对话的核心逻辑
 * @param params 对话参数
 * @returns AI生成的回应
 */
async function processSuspectDialogue(params: {
  caseId: string;
  suspectId: string;
  question: string;
  conversationHistory: Array<{
    role: 'detective' | 'suspect';
    content: string;
    timestamp: string;
  }>;
  timeRemaining: number;
  discoveredClues: string[];
}) {
  const { suspectId, question, conversationHistory, timeRemaining, discoveredClues } = params;
  
  // 分析问题类型
  const questionType = analyzeQuestionType(question);
  
  // 根据对话历史确定嫌疑人当前状态
  const currentState = analyzeSuspectState(conversationHistory, timeRemaining);
  
  // 检查是否有新线索被触发
  const triggeredClues = checkForTriggeredClues(question, questionType, discoveredClues);
  
  // 生成回应内容
  const response = generateSuspectResponse({
    suspectId,
    question,
    questionType,
    currentState,
    conversationHistory,
    timeRemaining
  });
  
  // 计算可疑度变化
  const suspicionChange = calculateSuspicionChange(questionType, currentState, triggeredClues.length);
  
  return {
    content: response.content,
    emotion: response.emotion,
    suspicionLevel: Math.max(1, Math.min(10, currentState.suspicionLevel + suspicionChange)),
    newClues: triggeredClues,
    hints: generateHints(questionType, currentState, triggeredClues)
  };
}

/**
 * 分析问题类型
 * @param question 侦探的问题
 * @returns 问题类型
 */
function analyzeQuestionType(question: string): string {
  const questionLower = question.toLowerCase();
  
  // 关键词映射
  const typeKeywords = {
    alibi: ['在哪', '什么时候', '时间', '不在场', '证明', '当时'],
    motive: ['为什么', '动机', '原因', '恨', '喜欢', '关系'],
    evidence: ['看到', '听到', '发现', '证据', '线索', '物品'],
    personal: ['你是', '背景', '工作', '家庭', '过去'],
    accusation: ['是你', '杀了', '凶手', '承认', '坦白'],
    emotional: ['感觉', '情绪', '害怕', '紧张', '难过']
  };
  
  for (const [type, keywords] of Object.entries(typeKeywords)) {
    if (keywords.some(keyword => questionLower.includes(keyword))) {
      return type;
    }
  }
  
  return 'general';
}

/**
 * 分析嫌疑人当前状态
 * @param conversationHistory 对话历史
 * @param timeRemaining 剩余时间
 * @returns 嫌疑人状态
 */
function analyzeSuspectState(conversationHistory: any[], timeRemaining: number) {
  const conversationCount = conversationHistory.length;
  const recentQuestions = conversationHistory.slice(-3).filter(msg => msg.role === 'detective');
  
  // 基础可疑度（随机生成，实际应该从数据库获取）
  let baseSuspicionLevel = Math.floor(Math.random() * 5) + 3;
  
  // 根据对话次数调整情绪
  let emotionalState: 'calm' | 'nervous' | 'angry' | 'sad' | 'defensive' = 'calm';
  
  if (conversationCount > 10) {
    emotionalState = 'angry';
    baseSuspicionLevel += 1;
  } else if (conversationCount > 6) {
    emotionalState = 'defensive';
  } else if (conversationCount > 3) {
    emotionalState = 'nervous';
  }
  
  // 根据时间压力调整
  if (timeRemaining < 5) {
    if (emotionalState === 'calm') emotionalState = 'nervous';
    baseSuspicionLevel += 1;
  }
  
  // 检查是否有重复或激进的问题
  const hasRepeatQuestions = recentQuestions.some((q1, i) => 
    recentQuestions.some((q2, j) => i !== j && q1.content.includes(q2.content.slice(0, 10)))
  );
  
  if (hasRepeatQuestions) {
    emotionalState = 'defensive';
    baseSuspicionLevel += 1;
  }
  
  return {
    suspicionLevel: Math.min(10, baseSuspicionLevel),
    emotionalState,
    conversationCount,
    timeRemaining,
    isStressed: timeRemaining < 10 || conversationCount > 8
  };
}

/**
 * 检查是否触发新线索
 * @param question 问题内容
 * @param questionType 问题类型
 * @param discoveredClues 已发现的线索
 * @returns 新触发的线索
 */
function checkForTriggeredClues(question: string, questionType: string, discoveredClues: string[]) {
  const newClues = [];
  
  // 根据问题类型和内容判断是否触发线索
  const clueTemplates = {
    alibi: {
      id: 'clue-alibi-inconsistency',
      description: '嫌疑人的不在场证明存在时间上的矛盾',
      type: 'testimony' as const,
      importance: 4,
      isRevealed: true,
      relatedSuspects: []
    },
    evidence: {
      id: 'clue-witness-testimony',
      description: '嫌疑人承认看到了关键证据',
      type: 'testimony' as const,
      importance: 3,
      isRevealed: true,
      relatedSuspects: []
    },
    motive: {
      id: 'clue-hidden-motive',
      description: '发现了嫌疑人隐藏的作案动机',
      type: 'circumstantial' as const,
      importance: 5,
      isRevealed: true,
      relatedSuspects: []
    }
  };
  
  // 检查特定问题是否触发线索
  if (questionType === 'alibi' && question.includes('具体') && Math.random() > 0.6) {
    const clue = clueTemplates.alibi;
    if (!discoveredClues.includes(clue.id)) {
      newClues.push(clue);
    }
  }
  
  if (questionType === 'evidence' && question.includes('看到') && Math.random() > 0.7) {
    const clue = clueTemplates.evidence;
    if (!discoveredClues.includes(clue.id)) {
      newClues.push(clue);
    }
  }
  
  if (questionType === 'motive' && question.includes('为什么') && Math.random() > 0.8) {
    const clue = clueTemplates.motive;
    if (!discoveredClues.includes(clue.id)) {
      newClues.push(clue);
    }
  }
  
  return newClues;
}

/**
 * 生成嫌疑人回应
 * @param params 回应参数
 * @returns 生成的回应
 */
function generateSuspectResponse(params: {
  suspectId: string;
  question: string;
  questionType: string;
  currentState: any;
  conversationHistory: any[];
  timeRemaining: number;
}) {
  const { suspectId, question, questionType, currentState } = params;
  
  // 根据嫌疑人ID获取人格特征（简化版，实际应从数据库获取）
  const suspectPersonalities = {
    'suspect-1': {
      name: '李助理',
      personality: '谨慎内向',
      responseStyle: 'formal',
      nervousTics: ['推眼镜', '整理文件', '低头不语']
    },
    'suspect-2': {
      name: '王同事',
      personality: '野心勃勃',
      responseStyle: 'confident',
      nervousTics: ['敲桌子', '看手表', '冷笑']
    },
    'suspect-3': {
      name: '陈清洁工',
      personality: '老实本分',
      responseStyle: 'humble',
      nervousTics: ['搓手', '结巴', '擦汗']
    }
  };
  
  const personality = suspectPersonalities[suspectId as keyof typeof suspectPersonalities] || {
    name: '嫌疑人',
    personality: '普通',
    responseStyle: 'neutral',
    nervousTics: ['沉默']
  };
  
  // 根据问题类型和情绪状态生成回应
  let content = '';
  let emotion = currentState.emotionalState;
  
  switch (questionType) {
    case 'alibi':
      content = generateAlibiResponse(personality, currentState);
      break;
    case 'motive':
      content = generateMotiveResponse(personality, currentState);
      break;
    case 'evidence':
      content = generateEvidenceResponse(personality, currentState);
      break;
    case 'personal':
      content = generatePersonalResponse(personality, currentState);
      break;
    case 'accusation':
      content = generateAccusationResponse(personality, currentState);
      emotion = currentState.emotionalState === 'calm' ? 'defensive' : 'angry';
      break;
    default:
      content = generateGeneralResponse(personality, currentState);
  }
  
  // 添加情绪表现
  if (currentState.isStressed) {
    const nervousTic = personality.nervousTics[Math.floor(Math.random() * personality.nervousTics.length)];
    content += ` *${nervousTic}*`;
  }
  
  return {
    content,
    emotion
  };
}

/**
 * 生成不在场证明相关回应
 */
function generateAlibiResponse(personality: any, state: any): string {
  const responses = {
    formal: [
      '我当时正在处理重要文件，有时间记录可以证明。',
      '根据我的日程安排，那个时间我在会议室。',
      '我可以提供详细的时间线来证明我的清白。'
    ],
    confident: [
      '我为什么要告诉你我在哪里？不过既然你问了，我当时在谈一个重要项目。',
      '我的时间很宝贵，不会浪费在这种事情上。',
      '有很多人可以证明我当时不在现场。'
    ],
    humble: [
      '我...我当时在打扫其他楼层，有监控可以看到。',
      '我只是个清洁工，为什么要怀疑我？',
      '我可以找同事来证明我当时在工作。'
    ]
  };
  
  const styleResponses = responses[personality.responseStyle as keyof typeof responses] || responses.formal;
  let response = styleResponses[Math.floor(Math.random() * styleResponses.length)];
  
  if (state.emotionalState === 'nervous') {
    response = response.replace('。', '...我真的没有撒谎。');
  }
  
  return response;
}

/**
 * 生成动机相关回应
 */
function generateMotiveResponse(personality: any, state: any): string {
  const responses = {
    formal: [
      '我与受害者只是普通的工作关系。',
      '虽然我们有些分歧，但不至于到那种程度。',
      '我承认我们之间有些矛盾，但这很正常。'
    ],
    confident: [
      '每个人都有不喜欢的同事，这不代表什么。',
      '商场如战场，有竞争很正常，但我不会做那种事。',
      '我有更好的方式解决问题，不需要用那种手段。'
    ],
    humble: [
      '我...我只是个小人物，没有理由伤害任何人。',
      '虽然有时候会被骂，但我不会记恨的。',
      '我需要这份工作，不会做傻事的。'
    ]
  };
  
  const styleResponses = responses[personality.responseStyle as keyof typeof responses] || responses.formal;
  return styleResponses[Math.floor(Math.random() * styleResponses.length)];
}

/**
 * 生成证据相关回应
 */
function generateEvidenceResponse(personality: any, state: any): string {
  const responses = {
    formal: [
      '我确实注意到了一些异常，但当时没有多想。',
      '如果这对调查有帮助，我可以详细说明我看到的情况。',
      '我记得那天有些不寻常的事情发生。'
    ],
    confident: [
      '我看到的东西可能对你们有用，但我需要确保自己的安全。',
      '有些事情我确实知道，但这不意味着我参与了。',
      '我观察力很强，确实注意到了一些细节。'
    ],
    humble: [
      '我...我可能看到了什么，但不确定重不重要。',
      '我不敢确定，可能是我看错了。',
      '如果真的有用的话，我可以告诉你们。'
    ]
  };
  
  const styleResponses = responses[personality.responseStyle as keyof typeof responses] || responses.formal;
  return styleResponses[Math.floor(Math.random() * styleResponses.length)];
}

/**
 * 生成个人背景相关回应
 */
function generatePersonalResponse(personality: any, state: any): string {
  const responses = {
    formal: [
      '我在这里工作已经有一段时间了，一直表现良好。',
      '我的背景很简单，没有什么特别的。',
      '我是个守法公民，从不惹麻烦。'
    ],
    confident: [
      '我的履历很光鲜，不需要向任何人证明什么。',
      '我取得今天的成就靠的是实力，不是运气。',
      '我的过去没有任何问题，可以随便调查。'
    ],
    humble: [
      '我就是个普通人，没什么特别的经历。',
      '我家境一般，靠自己的努力生活。',
      '我不是什么重要人物，只想安安静静工作。'
    ]
  };
  
  const styleResponses = responses[personality.responseStyle as keyof typeof responses] || responses.formal;
  return styleResponses[Math.floor(Math.random() * styleResponses.length)];
}

/**
 * 生成指控相关回应
 */
function generateAccusationResponse(personality: any, state: any): string {
  const responses = {
    formal: [
      '我强烈否认这个指控，我有充分的证据证明自己的清白。',
      '这是对我人格的侮辱，我要求你们拿出证据。',
      '我理解你们需要找到真凶，但请不要冤枉好人。'
    ],
    confident: [
      '你们在开玩笑吗？我为什么要做这种事？',
      '这个指控太荒谬了，我不会浪费时间回应。',
      '你们最好有确凿的证据，否则我会追究法律责任。'
    ],
    humble: [
      '不...不是我！我真的没有做过这种事！',
      '求求你们相信我，我是无辜的！',
      '我发誓我没有伤害任何人，请给我一个机会证明！'
    ]
  };
  
  const styleResponses = responses[personality.responseStyle as keyof typeof responses] || responses.formal;
  return styleResponses[Math.floor(Math.random() * styleResponses.length)];
}

/**
 * 生成一般性回应
 */
function generateGeneralResponse(personality: any, state: any): string {
  const responses = {
    formal: [
      '我会尽力配合调查，希望能早日找到真相。',
      '这件事对大家都是打击，希望尽快解决。',
      '我理解你们的工作，会如实回答问题。'
    ],
    confident: [
      '我时间有限，希望你们能问些有意义的问题。',
      '我已经说了该说的，没有更多要补充的。',
      '这种事情不应该发生，但既然发生了就要面对。'
    ],
    humble: [
      '我...我不知道该说什么，这太可怕了。',
      '我只希望真相能够大白，还大家一个公道。',
      '如果我能帮上什么忙，请尽管说。'
    ]
  };
  
  const styleResponses = responses[personality.responseStyle as keyof typeof responses] || responses.formal;
  return styleResponses[Math.floor(Math.random() * styleResponses.length)];
}

/**
 * 计算可疑度变化
 * @param questionType 问题类型
 * @param currentState 当前状态
 * @param newCluesCount 新线索数量
 * @returns 可疑度变化值
 */
function calculateSuspicionChange(questionType: string, currentState: any, newCluesCount: number): number {
  let change = 0;
  
  // 根据问题类型调整
  switch (questionType) {
    case 'accusation':
      change += 2;
      break;
    case 'motive':
      change += 1;
      break;
    case 'evidence':
      change += newCluesCount > 0 ? 2 : 0;
      break;
    case 'alibi':
      change += newCluesCount > 0 ? 1 : -1;
      break;
  }
  
  // 根据情绪状态调整
  if (currentState.emotionalState === 'nervous') change += 1;
  if (currentState.emotionalState === 'angry') change += 2;
  if (currentState.emotionalState === 'defensive') change += 1;
  
  return change;
}

/**
 * 生成给侦探的提示
 * @param questionType 问题类型
 * @param currentState 当前状态
 * @param newClues 新线索
 * @returns 提示列表
 */
function generateHints(questionType: string, currentState: any, newClues: any[]): string[] {
  const hints = [];
  
  if (newClues.length > 0) {
    hints.push('发现了新的线索！仔细分析可能会有重要发现。');
  }
  
  if (currentState.emotionalState === 'nervous') {
    hints.push('嫌疑人显得很紧张，可能隐瞒了什么。');
  }
  
  if (currentState.emotionalState === 'angry') {
    hints.push('嫌疑人情绪激动，可能触及了敏感话题。');
  }
  
  if (currentState.conversationCount > 8) {
    hints.push('对话次数较多，考虑换个角度或询问其他嫌疑人。');
  }
  
  if (questionType === 'alibi' && newClues.length === 0) {
    hints.push('尝试询问更具体的时间和地点细节。');
  }
  
  return hints;
}